Lambda the Ultimate

From this Wired article:

In 1976, computer pioneer Edsger W. Dijstra made an observation that would prove uncanny: "Program testing can be quite effective for showing the presence of bugs," he wrote in an essay, "but is hopelessly inadequate for showing their absence."

Thirty tears later, Dijsta's words have the ring of prophecy. Companies like Microsoft and Oracle, along with open-source projects like Mozilla and Linux, have all instituted rigorous and extensive testing programs, but bugs just keep slipping through. Last month, Microsoft's monthly drop of bug patches included fixes for 14 security holes that escaped prerelease testing, four of them rated "critical."

There's a bit to chew on here, including the by-now-de rigeur misidentification of Java, Python, and Perl as "type-safe languages." But I think the article is valuable in spite of that for its frank admission that even intense testing regimes aren't doing well at addressing serious quality issues. Daniel Jackson, leader of the Alloy project at MIT, is quoted.

See here for some examples/demos from Microsoft.

The papers presented at the International Workshop on Software Factories (held at OOPSLA 2005) are avialable online as well.

Microsoft's PDC videos are online, including some that are of interest to us.

Paul Vick directs us to three presentations: (1) the future of VB; (2) Dynamic languages on the CLR; (3) LINQ.

Note: You need to use IE to view these presentations.

(via Keith)

Io is small, pure object oriented, prototype-based programming language. The ideas in Io are mostly inspired by Smalltalk (all values are objects), Self, NewtonScript and Act1 (prototype-based differential inheritance, actors and futures for concurrency), LISP (code is a runtime inspectable/modifiable tree) and Lua (small, embeddable).

The paper and slides are available here.

Guess what I stumbled across at my local bookstore?

Previously mentioned on LtU, and now available... When the book was announced, Ehud said:

Authored by two of my favorites, Dan Friedman and Oleg, I have such high expectations, that however great the book is going to be, I am sure to be disappointed...

After working through the first five chapters (and sneaking a look at the implementation at the end), I'm pleased to announce that no one is likely to be disappointed... It's a real tour de force.

As expected, the focus this time is logic programming, in the form of a new set of primitives elegantly implemented around a backtracking monad in Scheme. Of course the format is familiar and comfortable, and of course it's charmingly illustrated by Duane Bibby.

So, get your copy today, and congratulations to the authors on a job well done!

As you can probably tell from my lack of posts recently, I am extremely busy. This is likely to continue for some time...

The purpose of this message is to remind our editorial team to post something ;-)

I am sure each of you has at least a couple of cool links you can come up with without too much effort...

An archive of videotaped Knuth lectures.

An outstanding tutorial on Lisp programming style by Peter Norvig and Kent Pitman. This to me is like Strunk & White: I re-read it every year or so and it always makes me cringe at what I've been writing lately.

The material is easy to relate to other higher-order languages. Translate your favourite slides into your language of choice and post them to the mailing list!

I recently put together video-iPod compatible feed of the classic SICP lectures.
Grab the feed: http://feeds.feedburner.com/SICP
(video RSS adventures documented here)

When the tutor said that Smalltalk has no case-statement, he meant it has no case-statement in the base class library.

Wiki page that shows you how to write a case construct with Smalltalk's surprisingly versatile syntax. Here's what it looks like:

aValue switch
   case: [matchCode1] then: [actionCode1];
   case: [matchCode2] then: [actionCode2];
   ...
   default: [otherCode].